/**
 * 
 */
package com.redis.api;

import java.io.Serializable;
import java.util.List;
import java.util.Set;

import com.redis.bean.KeyValue;


/**
 * @author yangjuanying
 */
public interface DataReader {
	
	/**
	 * 根据Key读取缓存中的Value
	 * @param key               索引的key
	 * @return
	 */
	public byte[] get(byte[] key);
	
	/**
	 * 根据Key读取缓存中的Value
	 * @param key               索引的key
	 * @return
	 */
	public String get(String key);
	
	/**
	 * 根据Key读取缓存中的Value,若缓存中不存在，则返回emptyDefault的值
	 * @param key               索引的key
	 * @param emptyDefault      缓存不存在时返回的缺省值
	 * @return
	 */
	public byte[] get(byte[] key, byte[] emptyDefault);
	
	/**
	 * 根据Key读取缓存中的Value,若缓存中不存在，则返回emptyDefault的值
	 * @param key               索引的key
	 * @param emptyDefault      缓存不存在时返回的缺省值
	 * @return
	 */
	public String get(String key, String emptyDefault);
	
	/**
	 * 根据Key读取缓存中的序列化对象
	 * @param key               索引的key
	 * @return
	 */
	public <T extends Serializable> T getBean(String key);

	/**
	 * 根据Key读取缓存中的序列化对象
	 * @param key               索引的key
	 * @return
	 */
	public <T extends Serializable> T getBean(String key, T t);
	
	/**
	 * 根据索引key和hash的域，从缓存中读取目标value
	 * @param key               索引的key
	 * @param field             hash域
	 * @return                
	 */
	public byte[] hget(byte[] key, byte[] field);
	
	/**
	 * 根据索引key和hash的域，从缓存中读取目标value,,若缓存中不存在，则返回emptyDefault的值
	 * @param key               索引的key
	 * @param field             hash域
	 * @param emptyDefault      缓存不存在时返回的缺省值
	 * @return                
	 */
	public byte[] hget(byte[] key, byte[] field, byte[] emptyDefault);
	
	/**
	 * 根据索引key和hash的域，从缓存中读取目标value
	 * @param key               索引的key
	 * @param field             hash域
	 * @return                
	 */
	public String hget(String key, String field);
	
	/**
	 * 根据索引key和hash的域，从缓存中读取目标value,,若缓存中不存在，则返回emptyDefault的值
	 * @param key               索引的key
	 * @param field             hash域
	 * @param emptyDefault      缓存不存在时返回的缺省值
	 * @return                
	 */
	public String hget(String key, String field, String emptyDefault);
	
	/**
	 * 根据索引key和hash的域，从缓存中读取目标序列化对象
	 * @param key               索引的key
	 * @param field             hash域
	 * @return                
	 */
	public <T extends Serializable> T hgetBean(String key, String field);
	
	/**
	 * 根据索引key和hash的域，从缓存中读取目标序列化对象,若缓存中不存在，则返回emptyDefault的值
	 * @param key               索引的key
	 * @param field             hash域
	 * @param t                 缓存不存在时返回的缺省值
	 * @return                
	 */
	public <T extends Serializable> T hgetBean(String key, String field, T emptyDefault);
	
	/**
	 * 根据索引key获取hash表所有域和值
	 * @param key
	 * @return
	 */
	public List<KeyValue> hgetAll(String key);
	
	/**
	 * 根据匹配规则获取匹配的key
	 * @param pattern           匹配规则,要获取缓存所有的域时pattern=*
	 * @return             
	 */
	public String[] keys(String pattern);
	
	/**
	 *回哈希表 key 中的所有域。
	 * @param key               索引的key    
	 * @return
	 */
	public String[] hkeys(String key);
	
	/**
	 * 根据匹配规则获取符合匹配规则的值
	 * @param pattern          key匹配规则
	 * @return
	 */
	public List<KeyValue> values(String pattern);
	
	/**
	 * 查询目标索引缓存的剩余生存时间
	 * 当 key 不存在时，返回 -2 。
	 * 当 key 存在但没有设置剩余生存时间时，返回 -1 。
     * 否则，以秒为单位，返回 key 的剩余生存时间。
	 * @param key
	 */
	public long ttl(String key);
	
	/**
	 * 与ttl方法类似，但返回的剩余生存时间为毫秒
	 * @param key                  索引的key
	 * @return
	 */
	public long pttl(String key);
	
	/**
	 * 查询目标缓存索引的数据值的类型
	 * @param key                  索引的key
	 * @return
	 * none (key不存在)
	 * string (字符串)
	 * list (列表)
	 * set (集合)
	 * zset (有序集)
	 * hash (哈希表)
	 */
	public String type(String key);
	
	/**
	 * 查询目标key索引的数据是否存在
	 * @param key                 索引的key
	 * @return
	 */
	public boolean exists(String key);
	
	/**
	 * 返回key索引的字符串的子字符串字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)
	 * 负数偏移量表示从字符串最后开始计数， -1 表示最后一个字符， -2 表示倒数第二个，以此类推。
	 * @param key                 索引的key
	 * @param start               起始位置
	 * @param end                 结束位置
	 * @return                    子串
	 */
	public String getRange(String key, int start, int end);
	
	/**
	 * 返回哈希表 key 中域的数量
	 * @param key                 索引的key  
	 * @return                    哈希表中域的数量。当 key 不存在时，返回 0 。
	 */
	public long hlen(String key);
	
	/**
	 * 根据目标索引获取对应的缓存数据
	 * @param pattern          key匹配规则
	 * @return
	 */
	public List<KeyValue> mget(String... key);
	
	/**
	 * 根据目标索引获取对应的缓存数据
	 * @param pattern          key匹配规则
	 * @return
	 */
	public List<KeyValue> mget(List<String> keys);
	
	/**
	 * 查询目标key索引的hash表中指定域数据是否存在
	 * @param key                 索引的key
	 * @param field               hash表的索引域
	 * @return
	 */
	public boolean hexists(String key, String field);
	
	/**
	 * 获取key索引的链表(LIST)的对应下标位置的数据值
	 * @param key                 索引的key
	 * @param index               链表的索引下标
	 * @return                    列表中下标为 index 的元素。如果 index 参数的值不在列表的区间范围内(out of range)，返回 null 。
	 */
	public byte[] lindex(String key, long index);
	
	/**
	 * 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
	 * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
     * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
	 * @param key                 索引的key
	 * @param start               开始下标
	 * @param end                 结束下标
	 * @return
	 */
	public List<byte[]> lrange(byte[] key, long start, long end);
	
	/**
	 * 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
	 * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
     * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
	 * @param key                 索引的key
	 * @param start               开始下标
	 * @param end                 结束下标
	 * @return
	 */
	public List<String> lrange(String key, long start, long end);
	
	/**
	 * 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
	 * 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
     * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
	 * @param key                 索引的key
	 * @param start               开始下标
	 * @param end                 结束下标
	 * @return
	 */
	public <T extends Serializable> List<T> lrangeBean(byte[] key, long start, long end);
	
	/**
	 * 返回列表 key 的长度。如果 key 不存在，则 key 被解释为一个空列表，返回 0 .如果 key 不是列表类型，返回一个错误。
	 * @param key                 索引的key
	 * @return
	 */
	public long llen(String key);
	
	/**
	 * 返回集合 key 的基数(集合中元素的数量)。
	 * @param key                 索引的key
	 * @return                    集合的基数。当 key 不存在时，返回 0 。
	 */
	public long scard(String key);
	
	/**
	 * 判断 member 元素是否集合 key 的成员
	 * @param key                 索引的key
	 * @return                    
	 */
	public boolean sismember(String key, byte[] member);
	
	/**
	 * 判断 member 元素是否集合 key 的成员
	 * @param key                 索引的key
	 * @return                    
	 */
	public boolean sismember(String key, String member);
	
	/**
	 * 判断 member 元素是否集合 key 的成员
	 * @param key                 索引的key
	 * @return                    
	 */
	public <T extends Serializable> boolean sismember(String key, T member);
	
	/**
	 * 返回集合 key 中的所有成员,不存在的 key 被视为空集合
	 * @param key                 索引的key
	 * @return
	 */
	public Set<byte[]> smembers(byte[] key);
	
	/**
	 * 返回集合 key 中的所有成员,不存在的 key 被视为空集合
	 * @param key                 索引的key
	 * @return
	 */
	public Set<String> smembers(String key);
	
	/**
	 * 返回集合 key 中的所有成员,不存在的 key 被视为空集合
	 * @param key                 索引的key
	 * @return
	 */
	public <T extends Serializable> Set<T> smembersBean(byte[] key);
	
	/**
	 * 合并多个集合的数据(并集，去重复)
	 * @param keys               索引的keys
	 * @return
	 */
	public Set<byte[]> sunion(byte[]... keys);
	
	/**
	 * 合并多个集合的数据(并集，去重复)
	 * @param keys               索引的keys
	 * @return
	 */
	public Set<String> sunion(String... keys);
	
	/**
	 * 合并两个集合的数据(并集，去重复)
	 * @param keys               索引的keys
	 * @return
	 */
	public <T extends Serializable> Set<T> sunionBean(byte[]... keys);
	
	/**
	 * 合并多个集合的数据(自动去除集合中值相同的元素)
	 * @param keys               索引的keys
	 * @return
	 */
	public Set<byte[]> sdiff(byte[]... keys);
	
	/**
	 * 合并多个集合的数据(自动去除集合中值相同的元素)
	 * @param keys               索引的keys
	 * @return
	 */
	public Set<String> sdiff(String... keys);
	
	/**
	 * 合并多个集合的数据(自动去除集合中值相同的元素)
	 * @param keys               索引的keys
	 * @return
	 */
	public <T extends Serializable> Set<T> sdiffBean(byte[]... keys);
	
	/**
	 * 合并多个集合的数据(取数据的交集)
	 * @param keys               索引的keys
	 * @return
	 */
	public Set<byte[]> sinter(byte[]... keys);
	
	/**
	 * 合并多个集合的数据(取数据的交集)
	 * @param keys               索引的keys
	 * @return
	 */
	public Set<String> sinter(String... keys);
	
	/**
	 * 合并多个集合的数据(取数据的交集)
	 * @param keys               索引的keys
	 * @return
	 */
	public <T extends Serializable> Set<T> sinterBean(byte[]... keys);
	
	/**
	 * 返回有序集 key 的基数
	 * @param key                索引的key
	 * @return
	 */
	public long zcard(String key);
	
	/**
	 * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
	 * @param key                索引的key
	 * @param min                最小score值
	 * @param max                最大score值
	 * @return                   成员的数量
	 */
	public long zcount(String key, double min, double max);
	
	/**
	 * 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递增(从小到大)来排序。
	 * 具有相同 score 值的成员按字典序(lexicographical order )来排列
	 * @param key                索引的key
	 * @param start              开始下标
	 * @param end                结束下标
	 * @return                   目标成员
	 */
	public Set<byte[]> zrange(byte[] key, long start, long end);
	
	/**
	 * 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递增(从小到大)来排序。
	 * 具有相同 score 值的成员按字典序(lexicographical order )来排列
	 * @param key                索引的key
	 * @param start              开始下标
	 * @param end                结束下标
	 * @return                   目标成员
	 */
	public Set<String> zrange(String key, long start, long end);
	
	/**
	 * 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递增(从小到大)来排序。
	 * 具有相同 score 值的成员按字典序(lexicographical order )来排列
	 * @param key                索引的key
	 * @param start              开始下标
	 * @param end                结束下标
	 * @return                   目标成员
	 */
	public <T extends Serializable> Set<T> zrangeBean(String key, long start, long end);
	
	/**
	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列
	 * @param key                索引的key
	 * @param min                最小score值
	 * @param max                最大score值
	 * @return
	 */
	public Set<byte[]> zrangeByScore(byte[] key, double min, double max);
	
	/**
	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列
	 * @param key                索引的key
	 * @param min                最小score值
	 * @param max                最大score值
	 * @return
	 */
	public Set<String> zrangeByScore(String key, double min, double max);
	
	/**
	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列
	 * @param key                索引的key
	 * @param min                最小score值
	 * @param max                最大score值
	 * @return
	 */
	public <T extends Serializable> Set<T> zrangeByScoreBean(String key, double min, double max);
	
	/**
	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列
	 * @param key                索引的key
	 * @param member             目标成员
	 * @return
	 */
	public long zrank(String key, byte[] member);
	
	/**
	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列
	 * @param key                索引的key
	 * @param member             目标成员
	 * @return
	 */
	public long zrank(String key, String member);
	
	/**
	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列
	 * @param key                索引的key
	 * @param member             目标成员
	 * @return
	 */
	public <T extends Serializable> long zrankBean(String key, T member);
	
	/**
	 * 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递增(从大到小)来排序。
	 * 具有相同 score 值的成员按字典序(lexicographical order )来排列
	 * @param key                索引的key
	 * @param start              开始下标
	 * @param end                结束下标
	 * @return                   目标成员
	 */
	public Set<byte[]> zrevrange(byte[] key, long start, long end);
	
	/**
	 * 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递增(从大到小)来排序。
	 * 具有相同 score 值的成员按字典序(lexicographical order )来排列
	 * @param key                索引的key
	 * @param start              开始下标
	 * @param end                结束下标
	 * @return                   目标成员
	 */
	public Set<String> zrevrange(String key, long start, long end);
	
	/**
	 * 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递增(从大到小)来排序。
	 * 具有相同 score 值的成员按字典序(lexicographical order )来排列
	 * @param key                索引的key
	 * @param start              开始下标
	 * @param end                结束下标
	 * @return                   目标成员
	 */
	public <T extends Serializable> Set<T> zrevrangeBean(String key, long start, long end);
	
	/**
	 * 返回有序集 key 中，成员 member 的 score 值。如果 member 元素不是有序集 key 的成员，或 key 不存在，返回null 。
	 * @param key
	 * @param member
	 * @return
	 */
	public Double zscore(String key, byte[] member);
	
	/**
	 * 返回有序集 key 中，成员 member 的 score 值。如果 member 元素不是有序集 key 的成员，或 key 不存在，返回null 。
	 * @param key
	 * @param member
	 * @return
	 */
	public Double zscore(String key, String member);
	
	/**
	 * 返回有序集 key 中，成员 member 的 score 值。如果 member 元素不是有序集 key 的成员，或 key 不存在，返回null 。
	 * @param key
	 * @param member
	 * @return
	 */
	public <T extends Serializable> Double zscoreBean(String key, T member);
	
	/**
	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从大到小)次序排列
	 * @param key                索引的key
	 * @param min                最小score值
	 * @param max                最大score值
	 * @return
	 */
	public Set<byte[]> zrevrangeByScore(byte[] key, double min, double max);
	
	/**
	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从大到小)次序排列
	 * @param key                索引的key
	 * @param min                最小score值
	 * @param max                最大score值
	 * @return
	 */
	public Set<String> zrevrangeByScore(String key, double min, double max);
	
	/**
	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从大到小)次序排列
	 * @param key                索引的key
	 * @param min                最小score值
	 * @param max                最大score值
	 * @return
	 */
	public <T extends Serializable> Set<T> zrevrangeByScoreBean(String key, double min, double max);
	
	/**
	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从大到小)顺序排列
	 * @param key                索引的key
	 * @param member             目标成员
	 * @return
	 */
	public long zrevrank(String key, byte[] member);
	
	/**
	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从大到小)顺序排列
	 * @param key                索引的key
	 * @param member             目标成员
	 * @return
	 */
	public long zrevrank(String key, String member);
	
	/**
	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从大到小)顺序排列
	 * @param key                索引的key
	 * @param member             目标成员
	 * @return
	 */
	public <T extends Serializable> long zrevrankBean(String key, T member);
	
	/**
	 * 将分页对象从有序集合中获取出来
	 * @param key                 索引的key
	 * @param pageNo              页码
	 * @param pageSize            分页大小
	 * @return                    成功加入的数量
	 */
	public <T extends Serializable> List<T> zgetPage(String key, int pageNo, int pageSize);
}

